/**
 * Virtual DOM patching algorithm based on Snabbdom by
 * Simon Friis Vindum (@paldepind)
 * Licensed under the MIT License
 * https://github.com/paldepind/snabbdom/blob/master/LICENSE
 *
 * modified by Evan You (@yyx990803)
 *

 /*
 * Not type-checking this because this file is perf-critical and the cost
 * of making flow understand it is not worth it.
 */

import VNode from './vnode'
import config from '../config'
import {SSR_ATTR} from 'shared/constants'
import {registerRef} from './modules/ref'
import {activeInstance} from '../instance/lifecycle'

import {
  warn,
  isDef,
  isUndef,
  isTrue,
  makeMap,
  isPrimitive
} from '../util/index'

export const emptyNode = new VNode('', {}, [])

//create: 在patch过程中，当根据vnode（简单的Vnode或组件Vnode)创建dom元素后，会调用create对应的钩子函数。
//update：在patch过程中，如果新旧Vnode符合sameVnode的要求，则会通过update根据新Vnode与旧Vnode的不同，
//      更新新Vnode。
//remove：在patch过程中，当调用removeVnodes方法根据vnode对象从其父dom元素中移除子dom元素时被调用。
//destroy:
const hooks = ['create', 'activate', 'update', 'remove', 'destroy']

function sameVnode(a, b) {
  return (
    //key可能同时为undefined
    a.key === b.key && (
      (
        a.tag === b.tag && //相同的标签
        a.isComment === b.isComment && //都是注释
        isDef(a.data) === isDef(b.data) && //只是针对a.tag === b.tag的判断，是否两个标签都存在data属性
        //如果标签是input，则两个input的type也必须相同，如果不是input，则直接返回true
        sameInputType(a, b)
      ) || ( //@todo 异步组件，暂不研究
        isTrue(a.isAsyncPlaceholder) &&
        a.asyncFactory === b.asyncFactory &&
        isUndef(b.asyncFactory.error)
      )
    )
  )
}

// Some browsers do not support dynamically changing type for <input>
// so they need to be treated as different nodes
//对于<input>标签，如果两个节点的type不同，则认为是不同的两个节点
function sameInputType(a, b) {
  if (a.tag !== 'input') return true
  let i
  const typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type
  const typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type
  return typeA === typeB
}

//遍历children数组，返回一个对象。该对象是获得每一项可能存在的key属性的值作为键，该项在数组中的
//下标作为值。
function createKeyToOldIdx(children, beginIdx, endIdx) {
  let i, key
  const map = {}
  for (i = beginIdx; i <= endIdx; ++i) {
    key = children[i].key
    if (isDef(key)) map[key] = i
  }
  return map
}

export function createPatchFunction(backend) {
  let i, j
  //cbs与vnode.data.hook有点相似，个人理解的两者之间的不同：
  //只有组件的vnode对象才会存在hook，而cbs是在所有的vnode对象上都会调用的钩子方法
  const cbs = {}

  const {modules, nodeOps} = backend

  for (i = 0; i < hooks.length; ++i) {
    cbs[hooks[i]] = []
    for (j = 0; j < modules.length; ++j) {
      if (isDef(modules[j][hooks[i]])) {
        cbs[hooks[i]].push(modules[j][hooks[i]])
      }
    }
  }

  function emptyNodeAt(elm) {
    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
  }

  function createRmCb(childElm, listeners) {
    function remove() {
      if (--remove.listeners === 0) {
        removeNode(childElm)
      }
    }

    remove.listeners = listeners
    return remove
  }

  //在dom树中移除el元素
  function removeNode(el) {
    const parent = nodeOps.parentNode(el)
    // element may have already been removed due to v-html / v-text
    if (isDef(parent)) {
      nodeOps.removeChild(parent, el)
    }
  }

  let inPre = 0

  /**
   * 该方法用于根据虚拟dom对象创建相应的dom元素，并将创建好的
   * dom元素插入可能存在的parentElm元素中。
   *
   * @param vnode
   * @param insertedVnodeQueue
   * @param parentElm 当前虚拟dom创建的元素的父元素
   * @param refElm 当前虚拟dom创建的元素的下一个兄弟元素，可能为null
   * @param nested
   */
  function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested) {
    //@todo isRootInsert属性的作用
    //猜测：isRootInsert好像是与transition动画有关，如果isRootInsert为true，表示
    //vnode对应的dom对象是初次或者重新创建的，并且该dom对象是整个初次或重新创建的dom树
    //的根节点，该vnode的子vnode的isRootInsert不会为true。
    vnode.isRootInsert = !nested // for transition enter check
    //对于Vue组件的虚拟dom对象，创建相应的组件dom
    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
      return
    }

    const data = vnode.data
    const children = vnode.children
    const tag = vnode.tag
    if (isDef(tag)) {//当前vnode对象对应一个html原生的标签
      if (process.env.NODE_ENV !== 'production') {
        if (data && data.pre) {
          inPre++
        }
        if (
          !inPre &&
          !vnode.ns &&
          !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&
          config.isUnknownElement(tag)
        ) {
          warn(
            'Unknown custom element: <' + tag + '> - did you ' +
            'register the component correctly? For recursive components, ' +
            'make sure to provide the "name" option.',
            vnode.context
          )
        }
      }
      //ns应该与svg有关
      vnode.elm = vnode.ns
        ? nodeOps.createElementNS(vnode.ns, tag)
        : nodeOps.createElement(tag, vnode)
      setScope(vnode)

      /* istanbul ignore if */
      if (__WEEX__) {
        // in Weex, the default insertion order is parent-first.
        // List items can be optimized to use children-first insertion
        // with append="tree".
        const appendAsTree = isDef(data) && isTrue(data.appendAsTree)
        if (!appendAsTree) {
          if (isDef(data)) {
            invokeCreateHooks(vnode, insertedVnodeQueue)
          }
          insert(parentElm, vnode.elm, refElm)
        }
        createChildren(vnode, children, insertedVnodeQueue)
        if (appendAsTree) {
          if (isDef(data)) {
            invokeCreateHooks(vnode, insertedVnodeQueue)
          }
          insert(parentElm, vnode.elm, refElm)
        }
      } else {
        createChildren(vnode, children, insertedVnodeQueue)
        if (isDef(data)) {
          invokeCreateHooks(vnode, insertedVnodeQueue)
        }
        insert(parentElm, vnode.elm, refElm)
      }

      if (process.env.NODE_ENV !== 'production' && data && data.pre) {
        inPre--
      }
    } else if (isTrue(vnode.isComment)) { //当前vnode对象对应一个注释
      vnode.elm = nodeOps.createComment(vnode.text)
      insert(parentElm, vnode.elm, refElm)
    } else { //当前vnode对象对应一个文本
      vnode.elm = nodeOps.createTextNode(vnode.text)
      insert(parentElm, vnode.elm, refElm)
    }
  }

  function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
    //模板相关属性的数据对象
    let i = vnode.data
    // 为什么data存在才进入if语句？
    // 只要是组件Vnode，就会生成相应的data属性，因为对于组件的vnode对象来说，至少会在create-component.js文件中
    // 通过mergeHooks方法添加相应的hook，所以data对象一定不为空。
    if (isDef(i)) {
      //什么情况下当前vnode对象会有componentInstance属性？
      //通过keepAlive包裹的组件
      const isReactivated = isDef(vnode.componentInstance) && i.keepAlive
      if (isDef(i = i.hook) && isDef(i = i.init)) {
        //在虚拟dom使用的不同阶段会调用不同的钩子方法，而这里就是调用钩子方法中的init方法
        //init方法的定义位置为：core/vdom/create-component.js-->componentVNodeHooks对象中。
        //而此时init方法就会根据当前虚拟dom创建相应的Vue实例，并挂载。
        i(vnode, false /* hydrating */, parentElm, refElm)
      }
      // after calling the init hook, if the vnode is a child component
      // it should've created a child instance and mounted it. the child
      // component also has set the placeholder vnode's elm.
      // in that case we can just return the element and be done.
      // 如果vnode.componentInstance存在，说明该vnode对象对应于一个组件，否则便是原生的标签。
      if (isDef(vnode.componentInstance)) {
        initComponent(vnode, insertedVnodeQueue)
        if (isTrue(isReactivated)) {
          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
        }
        return true
      }
    }
  }

  function initComponent(vnode, insertedVnodeQueue) {
    //pendingInsert是干嘛的？要弄明白它是干嘛的，必须先弄明白insertedVnodeQueue是干嘛的
    //答：首先要知道当前vnode是一个组件的vnode对象，所以在创建该vnode对象对应的vue实例时，也会
    //经过patch的过程，所以会在该vnode.data.pendingInsert添加insert的hook，所有组件的insert的hook
    //都会被汇总到根组件上运行，也就是放入insertedVnodeQueue数组中。
    if (isDef(vnode.data.pendingInsert)) {
      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert)
      vnode.data.pendingInsert = null
    }
    vnode.elm = vnode.componentInstance.$el
    if (isPatchable(vnode)) {
      invokeCreateHooks(vnode, insertedVnodeQueue)
      setScope(vnode)
    } else {
      // empty component root.
      // skip all element-related modules except for ref (#3455)
      registerRef(vnode)
      // make sure to invoke the insert hook
      insertedVnodeQueue.push(vnode)
    }
  }

  //@todo 这里是处理什么？
  //猜测：处理keep-alive组件中存在transition组件包裹的动态组件在切换时没有执行动画的bug。
  //这里的vnode变量就是指向keep-alive组件内部的子组件对象
  function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
    let i
    // hack for #4339: a reactivated component with inner transition
    // does not trigger because the inner node's created hooks are not called
    // again. It's not ideal to involve module-specific logic in here but
    // there doesn't seem to be a better way to do it.
    let innerNode = vnode
    while (innerNode.componentInstance) {
      innerNode = innerNode.componentInstance._vnode
      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
        //这里的innerNode对象是transition组件内部的子组件
        for (i = 0; i < cbs.activate.length; ++i) {
          cbs.activate[i](emptyNode, innerNode)
        }
        insertedVnodeQueue.push(innerNode)
        break
      }
    }
    // unlike a newly created component,
    // a reactivated keep-alive component doesn't insert itself
    insert(parentElm, vnode.elm, refElm)
  }

  //该方法用于将elm元素插入parent元素中，而可能存在的ref参数指向插入elm元素的位置之后的元素
  function insert(parent, elm, ref) {
    if (isDef(parent)) {
      if (isDef(ref)) {
        if (ref.parentNode === parent) {
          nodeOps.insertBefore(parent, elm, ref)
        }
      } else {
        nodeOps.appendChild(parent, elm)
      }
    }
  }

  function createChildren(vnode, children, insertedVnodeQueue) {
    if (Array.isArray(children)) {
      for (let i = 0; i < children.length; ++i) {
        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true)
      }
    } else if (isPrimitive(vnode.text)) {
      //@todo 什么情况下vnode对象既是一个标签，并且其text属性也存在值？
      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text))
    }
  }

  //vnode对应的节点是否为元素节点
  function isPatchable(vnode) {
    //如果vnode的componentInstance属性存在，则说明该vnode是Vue组件的虚拟dom对象，
    //而这里的while循环是从父级组件虚拟dom对象向Vue实例对应的虚拟dom对象前进，
    //直到获得第一个不是Vue组件虚拟dom对象，然后查看该虚拟dom对象是否是元素的虚拟dom对象
    while (vnode.componentInstance) {
      //@todo 什么情况下vnode.componentInstance._vnode不是指向一个元素节点？
      vnode = vnode.componentInstance._vnode
    }
    return isDef(vnode.tag)
  }

  //create hooks的调用时机是在dom对象创建之后，对于原生元素来说，
  //是在将原生元素插入父元素之前调用，但是对于组件来说，其创建的el元素已经被
  //插入父元素中。
  function invokeCreateHooks(vnode, insertedVnodeQueue) {
    for (let i = 0; i < cbs.create.length; ++i) {
      cbs.create[i](emptyNode, vnode)
    }
    i = vnode.data.hook // Reuse variable
    if (isDef(i)) {
      //@todo 未发现create的hook
      if (isDef(i.create)) i.create(emptyNode, vnode)
      //上面cbs的directives的create方法可能会加入insert的hook。
      //组件一定存在insert的hook，但是对于原生的标签，只有
      //存在需要处理的指令时，才会加入insert的hook，详情可见：core/vnode/modules/directives.js
      if (isDef(i.insert)) insertedVnodeQueue.push(vnode)
    }
  }

  // set scope id attribute for scoped CSS.
  // this is implemented as a special case to avoid the overhead
  // of going through the normal attribute patching process.
  //该方法为了支持html5的最新属性scoped，详情可查看vue-loader的官方文档以及
  //网上对html5的scoped属性的介绍。
  function setScope(vnode) {
    let i
    let ancestor = vnode
    while (ancestor) {
      if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
        nodeOps.setAttribute(vnode.elm, i, '')
      }
      ancestor = ancestor.parent
    }
    // for slot content they should also get the scopeId from the host instance.
    // 示例：
    // parent:'<div><child><div class="target">hello</div></child></div>'
    // child:'<div><slot></slot></div>'
    // child中的slot会被parent中的div.target代替，但是div.target创建的vnode对象的context属性
    // 指向parent组件对应的vue实例，这里为div.target设置child创建的vue实例上的_scopeId
    if (isDef(i = activeInstance) &&
      i !== vnode.context &&
      isDef(i = i.$options._scopeId)
    ) {
      nodeOps.setAttribute(vnode.elm, i, '')
    }
  }

  function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
    for (; startIdx <= endIdx; ++startIdx) {
      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm)
    }
  }

  function invokeDestroyHook(vnode) {
    let i, j
    //data是虚拟dom对象的选项数据对象
    const data = vnode.data
    if (isDef(data)) {
      //destroy的hook是在create-component.js的createComponent方法下调用mergeHooks方法设置的
      if (isDef(i = data.hook) && isDef(i = i.destroy)) i(vnode)
      //对于cbs的destroy来说，只有ref.js和directives.js中存在destroy钩子方法，ref.js用于处理$refs属性，
      //directives.js用于未处理的指令，而只有data存在的情况下，才会存在ref和指令，所以如果vnode.data不存在，
      //则无需调用cbs.destroy中的方法
      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode)
    }
    if (isDef(i = vnode.children)) {
      for (j = 0; j < vnode.children.length; ++j) {
        invokeDestroyHook(vnode.children[j])
      }
    }
  }

  //该方法用于调用相应的虚拟dom对象相应的钩子方法，并从父元素中移除虚拟dom对应的元素
  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
    for (; startIdx <= endIdx; ++startIdx) {
      const ch = vnodes[startIdx]
      if (isDef(ch)) {
        if (isDef(ch.tag)) {//元素或者组件节点
          //调用所有虚拟dom的cbs中的remove钩子方法和data.hook中的remove钩子方法
          removeAndInvokeRemoveHook(ch)
          invokeDestroyHook(ch)
        } else { // Text node
          removeNode(ch.elm)
        }
      }
    }
  }

  //猜测：该方法用于调用满足某些条件的虚拟dom对象的移除回调函数。
  function removeAndInvokeRemoveHook(vnode, rm) {
    //猜测：rm就是一个门闩，等到所有的移除回调函数执行完毕后，再销毁dom元素
    if (isDef(rm) || isDef(vnode.data)) {
      let i
      //这里加1是为了调用data.hook中的remove回调函数
      const listeners = cbs.remove.length + 1
      if (isDef(rm)) {
        // we have a recursively passed down rm callback
        // increase the listeners count
        rm.listeners += listeners
      } else {
        // directly removing
        // 在removeVnodes方法中会调用当前方法，所以只有是待移除的根vnode对象才会
        // 根据该根vnode对象对应的dom元素创建一个rm函数，也就是说，在当前方法执行的最后，
        // 会移除根dom对象，而不会主动移除其子dom对象，因为在移除根dom对象的过程中，子dom对象
        // 也会同时被移除。
        rm = createRmCb(vnode.elm, listeners)
      }
      // recursively invoke hooks on child component root node
      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
        removeAndInvokeRemoveHook(i, rm)
      }
      for (i = 0; i < cbs.remove.length; ++i) {
        //对于cbs.remove的回调函数，目前看来，只在modules/transition.js中存在。
        cbs.remove[i](vnode, rm)
      }

      //const listeners = cbs.remove.length + 1，这段代码加1，所以这里可以调用rm函数
      //@todo remove的hook在哪里？
      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
        i(vnode, rm)
      } else {
        //如果没有remove的hook，则会把 const listeners = cbs.remove.length + 1中的加一给减掉
        rm()
      }
    } else {
      removeNode(vnode.elm)
    }
  }

  function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
    let oldStartIdx = 0
    let newStartIdx = 0
    let oldEndIdx = oldCh.length - 1
    let oldStartVnode = oldCh[0]
    let oldEndVnode = oldCh[oldEndIdx]
    let newEndIdx = newCh.length - 1
    let newStartVnode = newCh[0]
    let newEndVnode = newCh[newEndIdx]
    let oldKeyToIdx, idxInOld, elmToMove, refElm

    // removeOnly is a special flag used only by <transition-group>
    // to ensure removed elements stay in correct relative positions
    // during leaving transitions
    // removeOnly在transition-group中使用为true，其它情况下都是false
    const canMove = !removeOnly

    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
      // 何时oldStartVnode和oldEndVnode会为undefined？
      // 在patch过程中，oldCh中的某些vnode对象会被设置为undefined，详情可查看
      // 最后一个else语句块的处理
      if (isUndef(oldStartVnode)) {
        oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
      } else if (isUndef(oldEndVnode)) {
        oldEndVnode = oldCh[--oldEndIdx]
      } else if (sameVnode(oldStartVnode, newStartVnode)) {
        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue)
        oldStartVnode = oldCh[++oldStartIdx]
        newStartVnode = newCh[++newStartIdx]
      } else if (sameVnode(oldEndVnode, newEndVnode)) {
        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue)
        oldEndVnode = oldCh[--oldEndIdx]
        newEndVnode = newCh[--newEndIdx]
      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue)
        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
        oldStartVnode = oldCh[++oldStartIdx]
        newEndVnode = newCh[--newEndIdx]
      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue)
        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
        oldEndVnode = oldCh[--oldEndIdx]
        newStartVnode = newCh[++newStartIdx]
      } else {
        //createKeyToOldIdx方法用于根据旧的子Vnode数组，获得以Vnode的key为键，下标为值的对象
        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
        idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null
        if (isUndef(idxInOld)) { // New element
          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)
          newStartVnode = newCh[++newStartIdx]
        } else {
          elmToMove = oldCh[idxInOld]
          /* istanbul ignore if */
          if (process.env.NODE_ENV !== 'production' && !elmToMove) {
            warn(
              'It seems there are duplicate keys that is causing an update error. ' +
              'Make sure each v-for item has a unique key.'
            )
          }
          if (sameVnode(elmToMove, newStartVnode)) {
            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue)
            oldCh[idxInOld] = undefined
            canMove && nodeOps.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm)
            newStartVnode = newCh[++newStartIdx]
          } else {
            // same key but different element. treat as new element
            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)
            newStartVnode = newCh[++newStartIdx]
          }
        }
      }
    }
    if (oldStartIdx > oldEndIdx) {
      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)
    } else if (newStartIdx > newEndIdx) {
      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx)
    }
  }

  /**
   * 该方法用于根据新旧vnode对象的不同，更新vue实例和dom对象，重点如下：
   * 1）在此过程中，无需重新创建vue实例，而是直接根据新vnode对象中的信息更新vue实例中的相关属性。
   */
  function patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly) {
    if (oldVnode === vnode) {
      return
    }

    const elm = vnode.elm = oldVnode.elm

    if (isTrue(oldVnode.isAsyncPlaceholder)) {
      if (isDef(vnode.asyncFactory.resolved)) {
        hydrate(oldVnode.elm, vnode, insertedVnodeQueue)
      } else {
        vnode.isAsyncPlaceholder = true
      }
      return
    }

    // reuse element for static trees.
    // note we only do this if the vnode is cloned -
    // if the new node is not cloned it means the render functions have been
    // reset by the hot-reload-api and we need to do a proper re-render.
    // 处理静态树和v-once指令，使之复用vnode对应的vue实例
    if (isTrue(vnode.isStatic) &&
      isTrue(oldVnode.isStatic) &&
      vnode.key === oldVnode.key &&
      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
    ) {
      vnode.componentInstance = oldVnode.componentInstance
      return
    }

    let i
    const data = vnode.data
    //只有Vue组件的虚拟dom对象存在prepatch钩子方法，对patch进行预处理，
    //所做的预处理主要是使用最新的虚拟dom对象更新对应的Vue实例的相关信息，
    //而不需要重新创建vue实例
    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
      i(oldVnode, vnode)
    }

    const oldCh = oldVnode.children
    const ch = vnode.children

    //这里是调用钩子方法，根据oldVnode和vnode的信息，更新vnode对应的元素。
    if (isDef(data) && isPatchable(vnode)) {
      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode)
      //@todo update的hook暂时未发现
      if (isDef(i = data.hook) && isDef(i = i.update)) i(oldVnode, vnode)
    }

    //对子虚拟dom以及元素进行更新
    //1）如果新旧children同时存在，并且不相等，则根据两个数组进行更新操作
    //2）如果新children存在，但是旧children不存在，则向vnode对应的dom元素中直接根据
    //  新children中的vnode创建dom对象
    //3）如果旧children存在，但是新children不存在，则销毁children对应的vue实例和dom对象
    //4）如果都不存在，但是oldVnode.text属性不为空，则置空
    if (isUndef(vnode.text)) {
      if (isDef(oldCh) && isDef(ch)) {
        if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
      } else if (isDef(ch)) { //新children存在，但是旧children不存在
        if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '')
        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)
      } else if (isDef(oldCh)) { //旧children存在，但是新children不存在
        removeVnodes(elm, oldCh, 0, oldCh.length - 1)
      } else if (isDef(oldVnode.text)) {
        nodeOps.setTextContent(elm, '')
      }
    } else if (oldVnode.text !== vnode.text) {
      nodeOps.setTextContent(elm, vnode.text)
    }
    if (isDef(data)) {
      //postpatch的hook插入回调函数的位置：
      //1）core/vnode/modules/directives.js --> _update方法中插入。
      if (isDef(i = data.hook) && isDef(i = i.postpatch)) i(oldVnode, vnode)
    }
  }

  function invokeInsertHook(vnode, queue, initial) {
    // delay insert hooks for component root nodes, invoke them after the
    // element is really inserted
    // 如果当前vue实例为子组件时，initial参数为true。而通过new Vue()的方式创建根vue实例时，
    // 该参数为false。
    // 这里代码的含义是：在初次patch时，如果当前vue实例是子组件的实例，则将insert hook保存在pendingInsert属性中，
    // 这样就可以在父组件中收集，并且最后会汇总到根vue实例中，然后就是此处else执行的逻辑，
    // 只有根vue实例才会运行else语句，运行整个vue实例树中的所有insert的hook。如果不是初次patch，则直接运行insert的hook
    if (isTrue(initial) && isDef(vnode.parent)) {
      vnode.parent.data.pendingInsert = queue
    } else {
      //insert的hook插入回调函数的位置：
      //1）在create-component.js中通过mergeHooks方法加入
      //2）core/vnode/modules/directives.js --> _update方法中插入，并且会在运行一次后，马上移除。
      //3）platforms/web/runtime/modules/transition.js中加入，也是只运行一次，马上移除
      for (let i = 0; i < queue.length; ++i) {
        queue[i].data.hook.insert(queue[i])
      }
    }
  }

  let bailed = false
  // list of modules that can skip create hook during hydration because they
  // are already rendered on the client or has no need for initialization
  const isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key')

  // Note: this is a browser-only function so we can assume elms are DOM nodes.
  function hydrate(elm, vnode, insertedVnodeQueue) {
    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
      vnode.elm = elm
      vnode.isAsyncPlaceholder = true
      return true
    }
    if (process.env.NODE_ENV !== 'production') {
      if (!assertNodeMatch(elm, vnode)) {
        return false
      }
    }
    vnode.elm = elm
    const {tag, data, children} = vnode
    if (isDef(data)) {
      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode, true /* hydrating */)
      if (isDef(i = vnode.componentInstance)) {
        // child component. it should have hydrated its own tree.
        initComponent(vnode, insertedVnodeQueue)
        return true
      }
    }
    if (isDef(tag)) {
      if (isDef(children)) {
        // empty element, allow client to pick up and populate children
        if (!elm.hasChildNodes()) {
          createChildren(vnode, children, insertedVnodeQueue)
        } else {
          let childrenMatch = true
          let childNode = elm.firstChild
          for (let i = 0; i < children.length; i++) {
            if (!childNode || !hydrate(childNode, children[i], insertedVnodeQueue)) {
              childrenMatch = false
              break
            }
            childNode = childNode.nextSibling
          }
          // if childNode is not null, it means the actual childNodes list is
          // longer than the virtual children list.
          if (!childrenMatch || childNode) {
            if (process.env.NODE_ENV !== 'production' &&
              typeof console !== 'undefined' &&
              !bailed
            ) {
              bailed = true
              console.warn('Parent: ', elm)
              console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children)
            }
            return false
          }
        }
      }
      if (isDef(data)) {
        for (const key in data) {
          if (!isRenderedModule(key)) {
            invokeCreateHooks(vnode, insertedVnodeQueue)
            break
          }
        }
      }
    } else if (elm.data !== vnode.text) {
      elm.data = vnode.text
    }
    return true
  }

  function assertNodeMatch(node, vnode) {
    if (isDef(vnode.tag)) {
      return (
        vnode.tag.indexOf('vue-component') === 0 ||
        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
      )
    } else {
      return node.nodeType === (vnode.isComment ? 8 : 3)
    }
  }

  //oldVnode参数的可能取值以及出现对应取值的场景：
  //1）dom元素节点：出现的场景是在创建Vue实例时，在挂载的时候为$mount方法提供了第一个参数el元素。提供el元素的情况一般是
  //  创建根Vue实例时，因为只有直接通过new操作创建的Vue实例才可提供el选项。可能还存在其他的情况，暂时还未发现。
  //2）null：初次创建Vue组件时，如果没有el选项，则oldVnode为null，直接通过vnode的信息创建html元素。一般为null的场景是
  //  根据子组件的信息创建对应的dom元素时，不会提供el元素，而是直接通过组件的vnode信息创建dom元素。
  //3）虚拟dom对象：在重渲染时，会传入真正的旧虚拟dom对象，
  return function patch(oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {
    //如果最新的虚拟dom对象是未定义的，但是旧的虚拟dom对象
    //存在，则说明是销毁。
    if (isUndef(vnode)) {
      if (isDef(oldVnode)) invokeDestroyHook(oldVnode)
      return
    }

    //只有在子组件中初次patch时isInitialPatch才为true，也就是说通过new Vue()的方式
    //创建根vue实例时，isInitialPatch为false
    let isInitialPatch = false
    const insertedVnodeQueue = []

    //只有在子组件中初次patch时oldVnode才会为undefined，对于通过new Vue()的方式来说
    //oldVnode指向el dom元素，对于重渲染来说，oldVnode指向旧vnode对象
    if (isUndef(oldVnode)) {
      // empty mount (likely as component), create new root element
      isInitialPatch = true
      createElm(vnode, insertedVnodeQueue, parentElm, refElm)
    } else { //如果旧虚拟dom对象和新虚拟dom对象都存在
      const isRealElement = isDef(oldVnode.nodeType)
      if (!isRealElement && sameVnode(oldVnode, vnode)) {
        // patch existing root node
        patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly)
      } else { //这个else的主要含义是：oldVnode与vnode不相同，至于为什么不相同，查看sameVnode方法，看看怎样的才是相同。
        //如果oldVnode和vnode不同，则根据vnode创建元素，然后删除oldVnode对应的元素
        //将元素节点对象包装为虚拟dom对象
        if (isRealElement) {
          // mounting to a real element
          // check if this is server-rendered content and if we can perform
          // a successful hydration.
          //@todo 应该是跟服务器端渲染相关，暂不研究
          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
            oldVnode.removeAttribute(SSR_ATTR)
            hydrating = true
          }
          if (isTrue(hydrating)) {
            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
              invokeInsertHook(vnode, insertedVnodeQueue, true)
              return oldVnode
            } else if (process.env.NODE_ENV !== 'production') {
              warn(
                'The client-side rendered virtual DOM tree is not matching ' +
                'server-rendered content. This is likely caused by incorrect ' +
                'HTML markup, for example nesting block-level elements inside ' +
                '<p>, or missing <tbody>. Bailing hydration and performing ' +
                'full client-side render.'
              )
            }
          }
          // either not server-rendered, or hydration failed.
          // create an empty node and replace it
          // 根据dom对象创建一个空的vnode
          oldVnode = emptyNodeAt(oldVnode)
        }
        // replacing existing element
        const oldElm = oldVnode.elm
        const parentElm = nodeOps.parentNode(oldElm)
        createElm(
          vnode,
          insertedVnodeQueue,
          // extremely rare edge case: do not insert if old element is in a
          // leaving transition. Only happens when combining transition +
          // keep-alive + HOCs. (#4590)
          oldElm._leaveCb ? null : parentElm,
          nodeOps.nextSibling(oldElm)
        )

        //parent属性具体指向哪个虚拟dom，可查看core/vdom/vnode.js下关于parent的解释
        if (isDef(vnode.parent)) {
          // component root element replaced.
          // update parent placeholder node element, recursively
          //ancestor是指向一个Vue组件的虚拟dom对象，Vue组件的虚拟dom对象本身不会创建
          //dom元素，而是通过Vue组件创建相应的Vue实例生成相应的dom元素，所以需要将Vue组件的虚拟dom对象的
          //elm属性指向Vue实例的虚拟dom对象对应的elm元素
          let ancestor = vnode.parent
          while (ancestor) {
            ancestor.elm = vnode.elm
            ancestor = ancestor.parent
          }
          if (isPatchable(vnode)) {
            for (let i = 0; i < cbs.create.length; ++i) {
              //@todo 注意，这里是使用vnode.parent调用create钩子函数，但是为什么也要对parent调用create？
              //猜测：对于当前组件来说，经过一次patch以后，其对应的根dom元素可能发生替换，也就是
              // 重新创建了一个新的dom元素，所以需要在父组件中对新创建的dom元素进行处理，比如需要设置事件监听等，
              //所以需要调用vnode.parent的钩子方法。
              cbs.create[i](emptyNode, vnode.parent)
            }
          }
        }

        if (isDef(parentElm)) {
          removeVnodes(parentElm, [oldVnode], 0, 0)
        } else if (isDef(oldVnode.tag)) {
          invokeDestroyHook(oldVnode)
        }
      }
    }

    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
    return vnode.elm
  }
}
